package xhwl.insurance.util;

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.util.Base64;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import xhwl.insurance.Constant;


/**
 * Created by admin on 2017/1/5.
 */

public class BitmapUtil {
    public static String bitmapToBase64(Bitmap bitmap) {
        String result = null;
        ByteArrayOutputStream baos = null;
        try {
            if (bitmap != null) {
                baos = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);

                baos.flush();
                baos.close();

                byte[] bitmapBytes = baos.toByteArray();
                result = Base64.encodeToString(bitmapBytes, Base64.DEFAULT);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.flush();
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
    public static String handleImage(Context context, String srcPath,int maxSize) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        BitmapFactory.Options newOpts = new BitmapFactory.Options();
        newOpts.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(srcPath, newOpts);// 打开空图片获取分辨率
        Log.e("压缩前分辨率：", newOpts.outWidth + "*" + newOpts.outHeight);
        newOpts.inSampleSize = getinSampleSize(newOpts);// 设置缩放倍数
        newOpts.inJustDecodeBounds = false;
        try {
            Bitmap bitmap1 = BitmapFactory.decodeFile(srcPath, newOpts);
            bitmap1.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        } catch (OutOfMemoryError e) {
            Log.e("OutOfMemoryError", "图片上传压缩初次分辨率失败");
        }
        Log.e("压缩后分辨率：", newOpts.outWidth + "*" + newOpts.outHeight);
        Log.e("分辨率压缩后的大小:", (baos.toByteArray().length / 1024) + "");

        //继续质量压缩
        Bitmap bitmap = null;
        int options = 90;
        while (baos.toByteArray().length / 1024 > maxSize) {
            if (bitmap == null)
                bitmap = BitmapFactory.decodeByteArray(baos.toByteArray(), 0,
                        baos.toByteArray().length);
            else
                baos.reset();
            bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);
            options -= 5;
        }
        Log.e("质量压缩后的大小:", (baos.toByteArray().length / 1024) + "");

        FileOutputStream out = null;
        File file = null;
        try {
            String suffix=srcPath.substring(srcPath.lastIndexOf("."));
            String cacheName=System.currentTimeMillis()+suffix;
            String cachePath=context.getCacheDir().getAbsolutePath()+ File.separator+"image"+ File.separator+cacheName;
            file=new File(cachePath);
            if (!file.getParentFile().exists())
                file.getParentFile().mkdirs();
            if (!file.exists())
                file.createNewFile();
            out = new FileOutputStream(file);
            out.write(baos.toByteArray());
            out.flush();
            out.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            try {
                out.close();
                baos.reset();
                baos = null;
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
//            Log.e("yung", "待上传图片压缩处理失败：" + file.getAbsolutePath());
            e.printStackTrace();
        }
        return file.getAbsolutePath();
    }
    /**
     * 获取图片压缩的比率
     *
     * @param options
     * @return
     */
    public static int getinSampleSize(BitmapFactory.Options options) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        float reqHeight = 800.0f;//根据自己需要确定分辨率长或者宽最大不超过960 并且按照原来比例
        float reqWidth = 480.0f;
        int inSampleSize = 1;

        if (height > width && height > reqHeight) {
            inSampleSize = (int) Math.ceil(height / reqHeight);

        } else if (height <= width && width > reqWidth) {
            inSampleSize = (int) Math.ceil(width / reqWidth);

        }
//        System.out.println("压缩前分辨率：" + width + "*" + height + "     压缩倍数："
//                + inSampleSize);
        return inSampleSize;
    }
    /**
     * 尺寸压缩
     * @param srcPath
     * @return
     */
    public static Bitmap compressImage(String srcPath) {
        BitmapFactory.Options newOpts = new BitmapFactory.Options();
        // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
        newOpts.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此时返回bm为空

        newOpts.inJustDecodeBounds = false;
        int w = newOpts.outWidth;
        int h = newOpts.outHeight;
        // 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
        float hh = 800f;// 这里设置高度为800f
        float ww = 480f;// 这里设置宽度为480f
        // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
        int be = 5;// be=1表示不缩放
        if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
            be = (int) (newOpts.outWidth / ww);
        } else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
            be = (int) (newOpts.outHeight / hh);
        }
        if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;// 设置缩放比例
        // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
        return bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
    }
    /**
     * @param bitmap
     * @param quality 0-100. 0 meaning compress for small size, 100 meaning compress for max quality(png ignore)
     * @param afterCompress 压缩后大小
     * @return
     */
    public static Bitmap compressImage(Bitmap bitmap, int quality, int afterCompress) {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 100;
        while (baos.toByteArray().length / 1024 > afterCompress) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
            baos.reset();// 重置baos即清空baos
            bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%，把压缩后的数据存放到baos中
            options -= 10;// 每次都减少10
        }
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());// 把压缩后的数据baos存放到ByteArrayInputStream中
        return bitmap = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
    }
    public static void saveFile(Context context,Bitmap bm, String fileName) throws IOException {
        File foder = new File(Constant.SAVE_PIC_PATH);
        if (!foder.exists()) {
            foder.mkdirs();
        }
        File myCaptureFile = new File(foder, fileName);
        if (!myCaptureFile.exists()) {
            myCaptureFile.createNewFile();
        }
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(myCaptureFile));
        bm.compress(Bitmap.CompressFormat.PNG, 100, bos);
        bos.flush();
        bos.close();

        Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
        Uri uri = Uri.fromFile(myCaptureFile);
        intent.setData(uri);
        context.sendBroadcast(intent);//这个广播的目的就是更新图库，发了这个广播进入相册就可以找到你保存的图片了！，记得要传你更新的file哦
    }
}
